package SO.Operaciones;

import EP.Ontologia.Ontologia;
import java.io.IOException;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.jdom.*;
import org.jdom.input.*;

/**
* @class OperacionesOntologia
* @author Mauricio Alvarez.
* @brief Esta clase contiene métodos de utilidad para operaciones de extracción, parseo, y otras sobre la ontología.
*/
public class OperacionesOntologia
{

    /** @var public Element raiz
     *  @brief variable global que guarda el elemento raíz de la ontología OWL.
    */
    public Element raiz = null;
    /** @var public Map<Integer,Ontologia> ontologia
     *  @brief variable global que guarda la ontología.
    */
    public Map<Integer,Ontologia> ontologia = null;
    /** @var  public int id_termino
     *  @brief variable global que guarda el identificador del término para la ontología.
    */
    public int id_termino = 1;

    
    //////////////////////////
    // CONSTRUCTOR
    //////////////////////////
    /**
     * @brief Constructor de la clase OperacionesOntologia.
     * @param no tiene.
     * @return void
    */
    public OperacionesOntologia()
    {
        ontologia = new HashMap<Integer,Ontologia>();
    }


    //////////////////////////
    // OPERACIONES
    //////////////////////////

    /**
     * @brief Carga la raíz de la ontología para comenzar a recorrer los conceptos que contiene.
     * @param no tiene.
     * @return List<Element>
    */
    public List<Element> CargarRaizOntologia() throws JDOMException, IOException
    {
            SAXBuilder builder=new SAXBuilder(false);
            //usar el parser Xerces y no queremos
            //que valide el documento
            Document doc = builder.build("C:\\Documents and Settings\\Mauricio\\Mis documentos\\NetBeansProjects\\Filtro\\Ontologia\\topicos.xml");
            //construyo el arbol en memoria desde el fichero
            // que se lo pasaré por parametro.
            raiz = doc.getRootElement();
            //cojo el elemento raiz
            System.out.println("============================");
            System.out.println("CONTRUCCIÓN de la ONTOLOGIA");
            System.out.println("============================");
            System.out.println("Raiz de la ontología:" +raiz.getName());
            //todos los hijos:
            List<Element> topicos = raiz.getChildren();
            System.out.println("Formada por :"+topicos.size()+" topicos");
            return topicos;

    }//FIN CargarRaizOntologia


    /**
     * @brief Parsea y extrae recursivamente el archivo XML en busca de los conceptos de la ontología.
     * @param no tiene.
     * @return void
    */
    public void parseoXML (List<Element> topicos, int nivel, int id_padre) throws ClassNotFoundException, InstantiationException, IllegalAccessException, SQLException
    {
         try {

             for(Element hijo: topicos)
             {
                System.out.println("============================");
                System.out.println("ONTOLOGIA NIVEL "+nivel);
                System.out.println("============================");
                
                // Obtenemos el nombre y su contenido de tipo texto
                String nombre = hijo.getName();

                if(nombre.compareTo("label") == 0){
                
                    String texto = hijo.getValue();

                    System.out.println(id_termino+".- Etiqueta: "+nombre);
                    System.out.println(id_termino+".- Texto: "+texto);
                    System.out.println(id_termino+".- id_padre: "+id_padre);
 
                    //Se agrega el nivel al HashMAP:
                    Ontologia onto = new Ontologia();
                    onto.setId_termino(id_termino);
                    onto.setId_padre(id_padre);
                    onto.setCantidad_hijos(nombre);
                    onto.setTermino(texto);
                    onto.setNivel(nivel);

                    ontologia.put(id_termino, onto);
                    nivel++;
                    id_padre = id_termino;
                    id_termino++;
                }

                // Si tiene descendientes hacemos la llamada recursiva:
                if (hijo.getChildren().size() > 0){
                    parseoXML (hijo.getChildren(), nivel, id_padre);
                }
                
            }

          }catch (Exception e) {
                e.printStackTrace();
          }

            
    }//FIN parseoXML


    /**
     * @brief Retorna la ontología parseada previamente parseada.
     * @param no tiene.
     * @return Map<Integer, Ontologia>
    */
    public Map<Integer, Ontologia> RetornarOntologia()
    {
        return ontologia;
    }//FIN RetornarOntologia


}//FIN OperacionesOntologia
